package com.android.helix;

import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

import android.content.Context;
import android.opengl.GLES20;
import android.opengl.Matrix;
import android.os.SystemClock;
import android.util.Log;


public class Scene3D {
	Scene3D(Context context){
		mContext = context;
		
		mVertices = ByteBuffer.allocateDirect(mTestObjectVerticesData.length
                * FLOAT_SIZE_BYTES).order(ByteOrder.nativeOrder()).asFloatBuffer();
		mVertices.put(mTestObjectVerticesData).position(0);
		

	}
	void onSurfaceCreated(){
	    // Ignore the passed-in GL10 interface, and use the GLES20
        // class's static methods instead.
        mProgram = createProgram(mVertexShader, mFragmentShader);
        if (mProgram == 0) {
            return;
        }
        maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
        checkGlError("glGetAttribLocation aPosition");
        if (maPositionHandle == -1) {
            throw new RuntimeException("Could not get attrib location for aPosition");
        }
        maTextureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord");
        checkGlError("glGetAttribLocation aTextureCoord");
        if (maTextureHandle == -1) {
            throw new RuntimeException("Could not get attrib location for aTextureCoord");
        }

        muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
        checkGlError("glGetUniformLocation uMVPMatrix");
        if (muMVPMatrixHandle == -1) {
            throw new RuntimeException("Could not get attrib location for uMVPMatrix");
        }
        
		// test vis object
		mVisObj = new VisObj(mContext, "characters/helix/main.(visobj).xml");
		
		//mTextureID = mVisObj.mTexture.mTextureID;
        Matrix.setLookAtM(mVMatrix, 0, 0, 0, -5, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
        
        prepareProgram();
        
	}
	
	public void onDrawFrame(){
		// Ignore the passed-in GL10 interface, and use the GLES20
		// class's static methods instead.
        GLES20.glClearColor(0.0f, 0.0f, 0.7f, 1.0f);
        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        //long time = SystemClock.uptimeMillis() % 4000L;
        //float angle = 0.090f * ((int) time);
        //Matrix.setRotateM(mMMatrix, 0, angle, 0, 0, 1.0f);
        
        float rotM[] = new float[16];
        Matrix.setRotateEulerM(rotM, 0, mDY, mDX, 0);
        //Matrix.multiplyMM(mMMatrix, 0, rotM, 0, mMMatrix, 0);
        
        Matrix.multiplyMM(mMVPMatrix, 0, mVMatrix, 0, rotM, 0);
        Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0);
        
/*
        GLES20.glUseProgram(mProgram);
        checkGlError("glUseProgram");
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mVisObj.mMesh.mSubsets[0].mTextures[0].mTextureID);
        
        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0);
        
        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0);
		GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
        mVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
        //GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false,
        //        TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mVertices);
        
        mVisObj.mMesh.mIndexVertexData.mVertexBuffer.position(0);
        GLES20.glVertexAttribPointer(maPositionHandle, 3, mVisObj.mMesh.mSubsets[0].mVertexDec[0].mType, false,
        		mVisObj.mMesh.mSubsets[0].mStride, mVisObj.mMesh.mIndexVertexData.mVertexBuffer);
        
        
        checkGlError("glVertexAttribPointer maPosition");
        mVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
        GLES20.glEnableVertexAttribArray(maPositionHandle);
        checkGlError("glEnableVertexAttribArray maPositionHandle");
        GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false,
                TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mVertices);
        checkGlError("glVertexAttribPointer maTextureHandle");
        GLES20.glEnableVertexAttribArray(maTextureHandle);
        checkGlError("glEnableVertexAttribArray maTextureHandle");

        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
        checkGlError("glDrawArrays");

*/       
        GLES20.glUseProgram(mVisObjProgram);
        checkGlError("glUseProgram");
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mVisObj.mMesh.mSubsets[0].mTextures[0].mTextureID);
        int MVPMatrixHandle = 0;
        
        MVPMatrixHandle = GLES20.glGetUniformLocation(mVisObjProgram, "MVPMatrix");
        if (MVPMatrixHandle == -1) {
            throw new RuntimeException("Could not get attrib location for MVPMatrix");
        }
        

        GLES20.glUniformMatrix4fv(MVPMatrixHandle, 1, false, mMVPMatrix, 0);
        mVisObj.draw(mVisObjProgram);
	}
	
	public void onSurfaceChanged(int width, int height){
        // Ignore the passed-in GL10 interface, and use the GLES20
        // class's static methods instead.
        GLES20.glViewport(0, 0, width, height);
        float ratio = (float) width / height;
        Matrix.frustumM(mProjMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
	}
	
    private int createProgram(String vertexSource, String fragmentSource) {
        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
        if (vertexShader == 0) {
            return 0;
        }

        int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
        if (pixelShader == 0) {
            return 0;
        }
        int program = GLES20.glCreateProgram();
        if (program != 0) {
            GLES20.glAttachShader(program, vertexShader);
            checkGlError("glAttachShader");
            GLES20.glAttachShader(program, pixelShader);
            checkGlError("glAttachShader");
            GLES20.glLinkProgram(program);
            int[] linkStatus = new int[1];
            GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
            if (linkStatus[0] != GLES20.GL_TRUE) {
                Log.e(TAG, "Could not link program: ");
                Log.e(TAG, GLES20.glGetProgramInfoLog(program));
                GLES20.glDeleteProgram(program);
                program = 0;
            }
        }
        return program;
    }
    private int loadShader(int shaderType, String source) {
    	int shader = GLES20.glCreateShader(shaderType);
    	if (shader != 0) {
    		GLES20.glShaderSource(shader, source);
    		GLES20.glCompileShader(shader);
    		int[] compiled = new int[1];
    		GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
    		if (compiled[0] == 0) {
                Log.e(TAG, "Could not compile shader " + shaderType + ":");
                Log.e(TAG, GLES20.glGetShaderInfoLog(shader));
                GLES20.glDeleteShader(shader);
                shader = 0;
    		}
    	}
    	return shader;	
    }
    
    private void checkGlError(String op) {
        int error;
        while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
            Log.e(TAG, op + ": glError " + error);
            throw new RuntimeException(op + ": glError " + error);
        }
    }
    
	private Context mContext;
    private final float[] mTestObjectVerticesData = {
            // X, Y, Z, U, V
            -1.0f, -0.5f, 0, -0.5f, 0.0f,
            1.0f, -0.5f, 0, 1.5f, -0.0f,
            0.0f,  1.11803399f, 0, 0.5f,  1.61803399f };

    FloatBuffer mVertices;
    private static final int FLOAT_SIZE_BYTES = 4;
    private int mProgram;
    private final String mVertexShader =
            "uniform mat4 uMVPMatrix;\n" +
            "attribute vec4 aPosition;\n" +
            "attribute vec2 aTextureCoord;\n" +
            "varying vec2 vTextureCoord;\n" +
            "void main() {\n" +
            "  gl_Position = uMVPMatrix * aPosition;\n" +
            "  vTextureCoord = aTextureCoord;\n" +
            "}\n";

    private final String mFragmentShader =
            "precision mediump float;\n" +
            "varying vec2 vTextureCoord;\n" +
            "uniform sampler2D sTexture;\n" +
            "void main() {\n" +
            "  gl_FragColor = texture2D(sTexture, vTextureCoord);\n" +
            "}\n";
    
    private static String TAG = "MyRenderer";
    
    private int maPositionHandle;
    private int maTextureHandle;
    private int muMVPMatrixHandle;
    //private int mTextureID;
    
    private float[] mVMatrix = new float[16];
    private float[] mProjMatrix = new float[16];
    
    private static final int TRIANGLE_VERTICES_DATA_POS_OFFSET = 0;
    private static final int TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES;
    private static final int TRIANGLE_VERTICES_DATA_UV_OFFSET = 3;
    
    private float[] mMVPMatrix = new float[16];
    private float[] mMMatrix = new float[16];
	
    VisObj mVisObj;
    private int mVisObjProgram;
	
    void prepareProgram(){
    	InputStream is;

    	String vertexSource = "";
    	String fragmentSource = "";
    	 
    	try {
    		is = mContext.getAssets().open(Utils.VERTEX_SHADER_PATH);
    		int size = is.available();
            byte[] buffer = new byte[size];
            is.read(buffer);
            is.close();

    		vertexSource = new String(buffer);

    	} catch (IOException e) {
			Log.e(Utils.TAG, "Could not load vertex shader: " + Utils.VERTEX_SHADER_PATH);
		}
    	try {
    		is = mContext.getAssets().open(Utils.FRAGMET_SHADER_PATH);
    		int size = is.available();
            byte[] buffer = new byte[size];
            is.read(buffer);
            is.close();

            fragmentSource = new String(buffer);

    	} catch (IOException e) {
			Log.e(Utils.TAG, "Could not load fragment shader: " + Utils.VERTEX_SHADER_PATH);
		}

    	mVisObjProgram = linkProgram(vertexSource, fragmentSource);
    }
    
    private int linkProgram(String vertexSource, String fragmentSource) {
        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
        if (vertexShader == 0) {
            return 0;
        }

        int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
        if (pixelShader == 0) {
            return 0;
        }
        int program = GLES20.glCreateProgram();
        if (program != 0) {
            GLES20.glAttachShader(program, vertexShader);
            checkGlError("glAttachShader");
            GLES20.glAttachShader(program, pixelShader);
            checkGlError("glAttachShader");
            
            for(int i = 0; i<Utils.VISOBJ_VERTEX_ATTRIB_NAMES.length; i++){
            	GLES20.glBindAttribLocation(program, i, Utils.VISOBJ_VERTEX_ATTRIB_NAMES[i]);
            }
            
            GLES20.glLinkProgram(program);
/*			int[] q1 = new int[8];
            for (int i = 0; i<8; i++){
            	q1[i] = GLES20.glGetAttribLocation(program, Utils.VISOBJ_VERTEX_ATTRIB_NAMES[i]);
            }
*/
            int[] linkStatus = new int[1];
            GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
            if (linkStatus[0] != GLES20.GL_TRUE) {
                Log.e(TAG, "Could not link program: ");
                Log.e(TAG, GLES20.glGetProgramInfoLog(program));
                GLES20.glDeleteProgram(program);
                program = 0;
            }
        }
        return program;
    }
    
    float mDX,mDY = 0;
}
